Language/OS - Multiplatform Resource Library/LANGUAGE OS.iso/lisp/wcl-21.lha/wcl-2.1/src/compiler/common/TAGS

Text File | 1992-09-10 | 22KB | 641 lines

analyze.lisp,3450
(defun add-control-point-tag-name 345,12450
(defun add-ftype-info 673,23785
(defun add-type-decls 1092,37877
(defun analyze 6,197
(defun analyze-atom 88,3255
(defun analyze-block 205,7295
(defun analyze-c-code 64,2562
(defun analyze-catch 242,8643
(defun analyze-constant 84,3148
(defun analyze-eval-when 68,2684
(defun analyze-funcall/apply 716,25133
(defun analyze-function 370,13318
(defun analyze-function-call 610,21692
(defun analyze-go 352,12663
(defun analyze-hairy-inline-function-call 761,26883
(defun analyze-if 170,5978
(defun analyze-inline-function-call 729,25714
(defun analyze-inline-mv-call 566,20127
(defun analyze-lambda-list 917,31974
(defun analyze-local-function-def 493,17654
(defun analyze-macrolet 474,17077
(defun analyze-multiple-value-call 553,19678
(defun analyze-mv-bind 545,19402
(defun analyze-named-function 393,14140
(defun analyze-named-function-call 634,22542
(defun analyze-procedure 419,15050
(defun analyze-progn 598,21324
(defun analyze-quote 79,3018
(defun analyze-return-from 262,9333
(defun analyze-setq 138,4891
(defun analyze-simple-inline-function-call 738,26100
(defun analyze-spec-bind 399,14338
(defun analyze-special-def 131,4661
(defun analyze-special-ref 124,4433
(defun analyze-switch 187,6599
(defun analyze-tagbody 302,10907
(defun analyze-the 1145,39521
(defun analyze-throw 290,10453
(defun analyze-unwind-protect 532,18863
(defun analyze-values 591,21125
(defun anonymous-function-expr? 1196,41109
(defun c-type->lisp-type 1214,41581
(defun collect-specials 1187,40801
(defun constant-expression-value 119,4341
(defun constant-expression? 110,4112
(defun cp-lookup 865,30385
(defun create-aux 1045,36218
(defun create-key 1002,34878
(defun create-optional 995,34654
(defun create-required-var 983,34340
(defun create-rest-var 990,34546
(defun current-procedure 892,31181
(defun declare-vars-volatile 901,31473
(defun fill-basic-optional-slots 1033,35865
(defun fixup-outer-control-points 336,12088
(defun flatten 1222,41725
(defun hairy->fixed-arg-list 794,27937
(defun hairy-lambda-list? 1179,40583
(defun inline-function? 1136,39195
(defun lambda-expr? 1199,41193
(defun legal-shorthand-type-decl-p 1099,38108
(defun list-basic-optional-vars 1028,35699
(defun local-procedure-name 383,13851
(defun lookup-block 877,30847
(defun lookup-dynamic-extent-decl 1116,38617
(defun lookup-function 883,30985
(defun lookup-ignore-decl 1121,38771
(defun lookup-inline-decl 1126,38909
(defun lookup-notinline-decl 1131,39049
(defun lookup-special-decl 1105,38267
(defun lookup-tag 880,30918
(defun lookup-type-decl 1110,38440
(defun lookup-variable 886,31063
(defun macroexpand-fully 52,2166
(defun maybe-remove-tail-recursion 706,24781
(defun merge-out-type 702,24674
(defun merge-types 697,24530
(defun new-decl-env 1087,37744
(defun new-fvar 1167,40227
(defun new-label 889,31141
(defun new-name-id 1210,41500
(defun new-var 1152,39742
(defun new-var-ref 1203,41276
(defun ok-foreign-declaration-p 1142,39436
(defun parse-decls 1048,36278
(defun print-call-types 691,24352
(defun procedure-required-vars 1184,40718
(defun push-basic-opt-vars-onto-env 1023,35487
(defun quoted-constant? 116,4269
(defun simple-keyword-arg-list 785,27699
(defun spec-bind-body 412,14866
(defun top-level-procedure 895,31239
(defun update-tmp-var-count 60,2427
(defun update-var-extent 905,31588
(defun var-lookup 857,30088

beta.lisp,512
(defun beta 3,72
(defun beta-body 23,715
(defun beta-control-point 150,4835
(defun beta-function-call 124,3923
(defun beta-if 131,4137
(defun beta-list 18,601
(defun beta-named-local 47,1437
(defun beta-progn 40,1215
(defun beta-scope-control-transfer 143,4560
(defun beta-seq 28,813
(defun beta-switch 137,4322
(defun beta-unwind-protect 155,4954
(defun beta-value? 89,2847
(defun beta-values 107,3500
(defun beta-var-def 120,3821
(defun beta-var-ref 111,3576
(defun collect-beta-pairs 62,1965

compile.lisp,1276
(defun append-files 82,2947
(defun back-end 224,7775
(defun com-1 211,7264
(defun comf 3,72
(defun comf-top-level-form 90,3204
(defun compile 323,10776
(defun compile-and-load-def 335,11147
(defun compile-define-compiler-macro-1 174,6004
(defun compile-define-function 135,4686
(defun compile-define-macro 159,5517
(defun compile-define-type 170,5896
(defun compile-define-var 193,6600
(defun compile-file 319,10706
(defun compile-top-level-add-winfo 109,3978
(defun compile-top-level-define-setf 178,6124
(defun compile-top-level-define-structure 183,6277
(defun compile-top-level-eval-when 126,4381
(defun compile-top-level-package-related-form 114,4073
(defun compile-top-level-proclaim 230,7889
(defun compile-top-level-progn 119,4198
(defun compiler-abort 284,9722
(defun compiler-warn 289,9851
(defun del-files 76,2833
(defun emit-configuration-info 65,2382
(defun enable-line-number-recording 314,10636
(defun file-init-thunk-name 87,3087
(defun form-name 304,10329
(defun get-or-create-variable-info 272,9363
(defun get-variable-info 269,9296
(defun initialize-compiler 344,11456
(defun proclaim-variable-type 277,9520
(defun proclaim-w 237,8097
(defun simple-constant? 205,7030
(defun special-var-p 281,9643
(defun w-warn 299,10207

compiler-macros.lisp,1878
(define-compiler-macro-w * 69,2054
(define-compiler-macro-w + 55,1705
(define-compiler-macro-w - 62,1866
(define-compiler-macro-w / 75,2230
(def-nary-optimizer < 84,2494
(def-nary-optimizer <= 83,2464
(def-nary-optimizer = 85,2523
(def-nary-optimizer > 82,2432
(def-nary-optimizer >= 81,2402
(define-compiler-macro-w append 103,2973
(define-compiler-macro-w aref 230,7252
(define-compiler-macro-w assoc 158,4864
(def-nary-optimizer char< 91,2703
(def-nary-optimizer char<= 90,2666
(def-nary-optimizer char= 87,2559
(def-nary-optimizer char> 89,2631
(def-nary-optimizer char>= 88,2594
(define-compiler-macro-w complement/2 147,4457
(defmacro def-nary-optimizer 3,72
(defun dyadicize-lr 16,443
(defun dyadicize-rl 11,282
(defun improve-writer 125,3635
(define-compiler-macro-w list 266,8312
(def-nary-optimizer logand 93,2739
(define-compiler-macro-w make-array 209,6605
(define-compiler-macro-w mapc 198,6288
(define-compiler-macro-w mapcan 192,6108
(define-compiler-macro-w mapcar 186,5929
(define-compiler-macro-w mapcon 195,6198
(define-compiler-macro-w mapl 201,6378
(define-compiler-macro-w maplist 189,6018
(define-compiler-macro-w member 150,4558
(define-compiler-macro-w memq 176,5548
(define-compiler-macro-w memql 173,5450
(define-compiler-macro-w nconc 110,3153
(defun optimize-simple-member 164,5155
(defun rewrite-mapping-form 36,1097
(define-compiler-macro-w schar 240,7563
(define-compiler-macro-w set-aref 235,7397
(define-compiler-macro-w set-schar 245,7714
(define-compiler-macro-w set-svref 258,8090
(defun simple-eq-version? 26,714
(defun simple-eql-version? 31,904
(define-compiler-macro-w svref 253,7936
(define-compiler-macro-w symbol-value 204,6468
(defun test-function 21,609
(define-compiler-macro-w typep 50,1564
(define-compiler-macro-w write 117,3330
(define-compiler-macro-w write-to-string 122,3513

compiler-methods.lisp,610
(define-compiler-method (add 3,72
(define-compiler-method (c_eql 9,439
(define-compiler-method (c_eql 11,533
(define-compiler-method (geq_p 17,854
(define-compiler-method (greaterp 14,628
(define-compiler-method (length 28,1191
(define-compiler-method (leq_p 16,779
(define-compiler-method (lessp 15,705
(define-compiler-method (logand/2 19,930
(define-compiler-method (logior/2 22,1017
(define-compiler-method (logxor/2 25,1104
(define-compiler-method (multiply 5,221
(define-compiler-method (num_equal_p 7,299
(define-compiler-method (num_equal_p 8,369
(define-compiler-method (subtract 4,144

configurations.lisp,611
(defstruct (config 7,130
(defparameter *config* 105,2697
(defparameter *debug-library-config*73,1792
(defparameter *decstation*152,3829
(defparameter *default-config*43,988
(defparameter *default-machine*166,4236
(defparameter *fastest-config*58,1387
(defvar *link-every-symbol?* 3,72
(defvar *link-every-symbol?* 107,2739
(defvar *profile?* 5,105
(defvar *profile?* 109,2772
(defparameter *safest-config*28,583
(defparameter *sparcstation-cc*139,3432
(defparameter *sparcstation-gcc*123,3002
(defparameter *standard-library-config*89,2240
(defstruct machine111,2797
(defun print-config 24,458

emit-code.lisp,2236
(defun add-external-procedure 261,8883
(defun code-mv? 103,3321
(defun code-with-side-effects? 433,15104
(defun emit-ansi-procedure-prototype 614,22043
(defun emit-binder-body 245,8302
(defun emit-body 235,8034
(defun emit-c-code 24,1027
(defun emit-code 5,173
(defun emit-cons-closure 210,7146
(defun emit-constant 51,1724
(defun emit-control-transfer 525,18539
(defun emit-foreign-call 384,13317
(defun emit-full-if 461,16104
(defun emit-function-call 87,2716
(defun emit-hairy-arg-code 652,23545
(defun emit-hairy-value-code 683,24662
(defun emit-hairy-var-code 690,24911
(defun emit-if 436,15175
(defun emit-inline-array-def 809,29297
(defun emit-inline-array-op 777,28161
(defun emit-inline-array-ref 783,28401
(defun emit-inline-mv-call 149,4880
(defun emit-keyword-arg-code 740,26654
(defun emit-misc-storage-decls 644,23215
(defun emit-named-call 267,9100
(defun emit-named-local 254,8625
(defun emit-non-ansi-fixed-procedure-decl 624,22453
(defun emit-non-ansi-hairy-procedure-decl 635,22865
(defun emit-optional-arg-code 701,25313
(defun emit-partial-if 473,16479
(defun emit-primitive-call 322,11220
(defun emit-procedure 106,3383
(defun emit-procedure-code 119,3759
(defun emit-procedure-extern-declaration 588,21040
(defun emit-procedure-prototype 603,21608
(defun emit-required-argc-check 638,22976
(defun emit-rest-arg-code 719,25991
(defun emit-restv-arg-code 731,26362
(defun emit-return-if-tail 41,1465
(defun emit-scope-control-transfer 530,18720
(defun emit-scope-seq 487,16950
(defun emit-seq 96,3069
(defun emit-spec-bind-seq 218,7377
(defun emit-switch 445,15484
(defun emit-tag-control-point 564,20145
(defun emit-tag-control-transfer 555,19778
(defun emit-tag-seq 512,18015
(defun emit-unnamed-call 296,10204
(defun emit-unwind-protect 567,20232
(defun emit-values 169,5685
(defun emit-var-def 70,2224
(defun emit-var-ref 57,1865
(defun genstring 582,20845
(defun inline-array-op? 761,27519
(defun inner-procedure-needs-oe? 192,6526
(defun lisp-type->c-type 838,30306
(defun lookup-outer-environment-offset 575,20579
(defun maybe-emit-assignment 38,1378
(defun result-var-name 31,1256
(defun setup-oe-if-needed 196,6660
(defun tmp-var-name 585,20944

emit-data.lisp,731
(defun compiled-function-name 159,5172
(defun emit-bignum 193,6314
(defun emit-compiled-function 163,5283
(defun emit-complex-1d-array 126,4206
(defun emit-complex-multi-array 130,4300
(defun emit-cons 47,1409
(defun emit-data 5,179
(defun emit-float 44,1337
(defun emit-foreign-symbol 41,1286
(defun emit-lref 36,1154
(defun emit-multi-array 61,1842
(defun emit-null-oe-procedure 52,1553
(defun emit-simple-1d-array 91,2864
(defun emit-simple-multi-array 135,4413
(defun emit-simple-multi-array 141,4610
(defun emit-simple-string 76,2317
(defun emit-string-using-c-syntax 66,1985
(defun emit-structure 168,5491
(defun emit-vector 56,1661
(defun ref-structure-as-vector 154,5039
(defun winbig-fixnum? 188,6185

format-compiler.lisp,30
(defun compile-format 16,693

freeze.lisp,514
(defun freeze 4,152
(defun freeze-constant 20,825
(defun freeze-control-point 105,3496
(defun freeze-function-call 79,2603
(defun freeze-if 87,2878
(defun freeze-list 44,1566
(defun freeze-list-with-var-names 53,1811
(defun freeze-procedure 35,1184
(defun freeze-scope-control-transfer 98,3199
(defun freeze-seq 58,1959
(defun freeze-unwind-protect 109,3630
(defun freeze-values 75,2509
(defun freeze-var-def 30,1036
(defun freeze-var-ref 25,931
(defun name-result 120,3977
(defun tmp-var 117,3886

function-info.lisp,744
(defun add-compiler-method 9,303
(defun add-foreign-function-info 128,4250
(defun add-function-call-info 77,2621
(defun add-procedure-definition 35,1195
(defun add-undefined-function 71,2441
(defun clear-undefined-functions 81,2691
(defmacro define-compiler-method 3,72
(defun define-primitive 143,4700
(defun delete-procedure-info 65,2324
(defun delete-undefined-function 74,2540
(defun get-or-create-procedure-info 30,1035
(defun get-procedure-info 27,967
(defun list-undefined-functions 84,2763
(defun load-procedure-info 111,3698
(defun proclaim-ftype-info 50,1849
(defun proclaim-inline-function 56,2073
(defun proclaim-notinline-function 60,2193
(defun save-procedure-info 89,2936
(defun validate-function-call 68,2395

globals.lisp,2933
(defstruct (branch 128,2665
(defstruct (c-code 10,155
(defstruct (compiler-method 220,4415
(defstruct (constant 125,2618
(defstruct (control-point 28,554
(defstruct (control-transfer 42,927
(defstruct (foreign-call 161,3216
(defstruct (foreign-info 217,4336
(defstruct (function-and-method-info 207,4127
(defstruct (function-call 152,3053
(defstruct (function-var 112,2390
(defstruct (if 132,2725
(defstruct (inline-mv-call 141,2846
(defstruct (inner-procedure 69,1563
(defstruct (keyword 96,2011
(defstruct (named-call 158,3149
(defstruct (named-local 148,2967
(defstruct (optional 94,1959
(defstruct (primitive-call 167,3353
(defstruct (primitive-info 223,4483
(defstruct (procedure 58,1314
(defstruct (procedure-info 210,4202
(defstruct (progn 20,379
(defstruct (scope-control-point 37,793
(defstruct (scope-control-transfer 46,1031
(defstruct (scope-seq 22,415
(defstruct (seq 13,202
(defstruct (spec-bind-seq 55,1252
(defstruct (switch 136,2775
(defstruct (tag-control-point 40,867
(defstruct (tag-control-transfer 49,1110
(defstruct (tag-seq 25,489
(defstruct (top-level-procedure 74,1654
(defstruct (unnamed-call 163,3269
(defstruct (unwind-protect 51,1174
(defstruct (values 145,2922
(defstruct (values-seq 17,329
(defstruct (var-def 120,2543
(defstruct (var-ref 116,2476
(defstruct (variable-var 114,2433
(defvar *analysis-errors*)295,6223
(defvar *break-on-compiler-warn?* 297,6251
(defvar *c-stream*)169,3408
(defvar *compile-file-pathname*)301,6346
(defvar *compiler-initialized?* 307,6485
(defvar *compiler-package*309,6523
(defvar *const-labels*)174,3525
(defvar *delay-procedure-emit?* 175,3549
(defvar *disable-position-independent-code?* 303,6380
(defvar *emitting-procedure?* 291,6158
(defvar *env*)235,4644
(defvar *external-procedures* 287,6086
(defvar *inner-procedures*)293,6194
(defvar *k-stream*)171,3450
(defvar *keyword-package* 299,6293
(defvar *libraries* 305,6431
(defvar *name-id-counter*)177,3613
(defvar *ok-foreign-declarations* 250,5429
(defvar *package-stream*)172,3470
(defvar *procedure-chain* 178,3640
(defvar *standard-type-specifier-symbols*237,4660
(defvar *string-counter* 173,3496
(defvar *structure-info* 285,6031
(defvar *tmp-var-counter*)176,3586
(defvar *undefined-functions* 198,3986
(defvar *variable-info* 283,5977
(defvar *win-stream*)170,3428
(defstruct application-symbol180,3672
(defconstant argc-var-name 289,6122
(defstruct basic-optional88,1868
(defstruct code3,72
(defconstant constant-symbol-flag 192,3879
(defstruct decls 253,5527
(defstruct foreign-symbol195,3951
(defstruct function-info200,4057
(defstruct label 271,5836
(defstruct lex-env 226,4548
(defstruct library277,5918
(defconstant macro-symbol-flag 193,3916
(defconstant special-symbol-flag 191,3843
(defstruct static-structure273,5860
(defstruct var                ; 99,2072
(defstruct var-info77,1744
(defstruct variable-info        ; 264,5685

improve.lisp,643
(defun call-matches-method-type-signature? 83,2575
(defun clear-tree-leaves-tail-slots 184,6286
(defun function-call-side-effects? 205,7179
(defun improve 3,72
(defun improve-constant 19,695
(defun improve-control-point 154,5247
(defun improve-function-call 55,1577
(defun improve-if 94,3053
(defun improve-list 22,756
(defun improve-scope-control-transfer 147,4975
(defun improve-seq 31,963
(defun improve-switch 140,4722
(defun improve-unwind-protect 158,5363
(defun improve-values 44,1331
(defun improve-var-def 51,1477
(defun improve-var-ref 48,1417
(defun primitive-rewrite-possible? 74,2205
(defun tail-leaves 165,5605

link.lisp,2750
(defvar *char-conversions*25,628
(defparameter *decls-files* 321,9208
(defparameter *eval-files* 325,9276
(defvar *link-start-time*)347,10086
(defvar *pinfo-load-date* 3,72
(defvar *rtl-files*)323,9254
(defvar *symbols* 107,3015
(defun add-static-structure 171,5130
(defun application-structure-predicate 335,9618
(defun bin-file-pathname 270,8247
(defun binary-pathname 592,18371
(defun build 621,19155
(defun build-1 627,19279
(defun build-aux-files 365,10633
(defun build-bin 624,19216
(defun build-debugging-library 703,21551
(defun build-library 711,21795
(defun build-standard-library 707,21672
(defun c-pathname 589,18314
(defun comdecls 744,22653
(defun compile-file-list 760,23307
(defun compute-decls 285,8606
(defun compute-eval-files 315,9068
(defun comrtl 753,23021
(defun decimal-integer-length 41,1042
(defun decls-file-pathname 276,8381
(defun elapsed-link-time 349,10114
(defun emit-application-procedure 109,3076
(defun emit-application-symbol 117,3311
(defun emit-package-symbols 355,10269
(defun eval-file-pathname 279,8455
(defun get-sym 138,4069
(defun invoke-c-compiler 595,18433
(defun invoke-linker 609,18916
(defun legal-c-var-char? 22,547
(defun library-symfile 545,16844
(defun link-application 481,14893
(defun link-application-files 436,13329
(defun link-application-symbol? 343,9965
(defun link-default-library 586,18234
(defun link-msg 352,10189
(defun link-shared-library 519,16096
(defun lisp->c-block-name 89,2601
(defun lisp->c-function-name 83,2459
(defun lisp->c-name 47,1163
(defun lisp->c-procedure-name 100,2827
(defun lisp->c-symbol-name 95,2735
(defun lisp->c-tag-name 92,2669
(defun lisp->c-variable-name 86,2530
(defun load-pinfo 662,20203
(defun lookup-library 5,104
(defsetf lookup-library 11,263
(defun macro-package-abbrev 19,469
(defun make-c-src-clean 684,20929
(defun make-lib 693,21206
(defun newer-file? 655,20060
(defun pinfo-file-pathname 282,8527
(defun procedure-package-abbrev 16,387
(defun read-index 738,22473
(defun read-library-symbol-info 563,17448
(defun read-library-version 687,21028
(defun save-pinfo 674,20641
(defun set-application-symbol-flag 154,4482
(defun set-function 165,4904
(defun set-lookup-library 8,172
(defun set-value 158,4636
(defun setup-application-symbols 184,5637
(defun source-newer? 652,19964
(defun sub-pathname 735,22389
(defun successful-status? 616,19098
(defun sym-data 149,4368
(defun symbol-init->c-code 238,7224
(defun symbol-package-abbrev 13,308
(defun test-file-pathname 273,8313
(defun transitive-structure-children 327,9326
(defun update-indices 679,20786
(defun update-library 728,22242
(defun w-tree-file-pathname 264,8095
(defun write-library-symbol-info 548,16924

macros.lisp,29
(defmacro defprimitive 3,72

primitives.lisp,1670
(defprimitive %* 23,684
(def-arith-op/2 %+ 11,387
(def-arith-op/2 %- 12,411
(defprimitive %32bit-def 88,2911
(defprimitive %32bit-ref 85,2818
(def-arith-predicate/2 %< 18,555
(def-arith-predicate/2 %<= 19,586
(def-arith-predicate/2 %= 17,523
(def-arith-predicate/2 %> 20,619
(def-arith-predicate/2 %>= 21,650
(defprimitive %ashl 64,2032
(defprimitive %ashr 67,2142
(defprimitive %bit-clear 134,4532
(defprimitive %bit-set 130,4395
(defprimitive %bit-test 123,4158
(defprimitive %boundp 112,3709
(defprimitive %char-code 106,3552
(defprimitive %code-char 103,3476
(defprimitive %dbp 146,5019
(defprimitive %div 26,808
(defprimitive %eq 52,1688
(defprimitive %fboundp 117,3925
(defprimitive %fixnump 32,1047
(defprimitive %int->double 109,3627
(defprimitive %ldb 142,4844
(def-arith-op/2 %logand 13,435
(def-arith-op/2 %logior 14,464
(defprimitive %lognot 61,1952
(def-arith-op/2 %logxor 15,493
(defprimitive %makunbound 120,4056
(defprimitive %null-foreign-pointer? 55,1768
(defprimitive %numberp 48,1556
(defprimitive %object-length 73,2377
(defprimitive %pointer 58,1873
(defprimitive %rem 29,939
(defprimitive %schar 97,3253
(defprimitive %set-object-length 70,2254
(defprimitive %set-schar 100,3353
(defprimitive %set-structure-elt 79,2575
(defprimitive %signed-32bit-def 94,3134
(defprimitive %signed-32bit-ref 91,3021
(defprimitive %structure-elt 76,2470
(defprimitive %symbol-function 82,2709
(defprimitive %tag 35,1125
(defprimitive %tag= 41,1307
(defprimitive %tag_mask 38,1203
(defprimitive %tag_mask= 44,1416
(defprimitive %word-ptr 127,4297
(defmacro def-arith-op/2 3,72
(defmacro def-arith-predicate/2 7,230

tree-nsubst.lisp,403
(defun tree-nsubst 3,72
(defun tree-nsubst-control-point 75,2578
(defun tree-nsubst-function-call 47,1510
(defun tree-nsubst-if 54,1757
(defun tree-nsubst-list 21,735
(defun tree-nsubst-scope-control-transfer 67,2269
(defun tree-nsubst-seq 26,871
(defun tree-nsubst-switch 60,1986
(defun tree-nsubst-unwind-protect 80,2719
(defun tree-nsubst-values 39,1288
(defun tree-nsubst-var-def 43,1386

type-dispatch.lisp,542
(defvar *fixnum-spec* 5,117
(defun array-type->type-codes 231,7313
(defun duplicates? 7,196
(defun find->hashed-symbol-lookup 33,961
(defun flatten-multi-cases 121,3913
(defconstant max-no-collision-tries 3,72
(defun no-collision-hash-size 14,389
(defun no-collision-hash-size-1 19,535
(defun optimize-case 46,1412
(defun optimize-case/chars 74,2472
(defun optimize-case/fixnums 67,2243
(defun optimize-case/symbols 96,3087
(defun optimize-typecase 143,4640
(defun optimize-typecase-1 239,7604
(defun type->type-codes 213,6738